// for (let i = 0; i < 20; i++) {
//     if (i === 10) {
//         continue;
//     }
//
//     console.log(i);
// }

function loop(i) {
    if (i >= 20) {
        return
    }

    if (i === 10) {
        return loop(i + 1)
    }

    console.log(i);
    loop(i + 1);
}

// loop(0);


const tree = [
    {
        id: 1,
        childNodes: [
            {
                id: 1.1,
                childNodes: [
                    {
                        id: 1.11,
                        childNodes: [],
                    },
                    {
                        id: 1.12,
                        childNodes: [],
                    },
                ],
            },
            {
                id: 1.2,
                childNodes: [
                    {
                        id: 1.21,
                        childNodes: [],
                    },
                    {
                        id: 1.23,
                        childNodes: [],
                    },
                ],
            },
            {
                id: 1.3,
                childNodes: [
                    {
                        id: 1.31,
                        childNodes: [],
                    },
                    {
                        id: 1.32,
                        childNodes: [],
                    },
                    {
                        id: 1.33,
                        childNodes: [],
                    },
                ],
            },
        ],
    }
]

// for () {
//     for () {
//         for () {
//             for () {
//             }
//         }
//     }
// }

/**
 * 递归调用可以实现，无限层数的循环
 * @param nodes
 */
// 递归根节点为数组的情况
function callback(nodes = []) {
    for (let node of nodes) {
        console.log(node);
        callback(node.childNodes);
    }
}

// 递归：根节点是 单一节点的情况
function callback(node) {
    if (!node) {
        return
    }

    console.log(node);

    for (let sub_node of node.childNodes) {
        callback(sub_node);
    }
}

// callback(tree);


const ad = function arr(a) {
    return a < 2 ? 1 : a * arr(a - 1);
}


/**
 * eval 艾vol
 * 它可以 [执行] 任意JavaScript代码
 * 所以它，极度危险
 */
function test_eval() {
    const a = 15;
    let c;

    function add(a, b) {
        return a + b;
    }

    eval(' add(a, 21) '); // 传入代码字符串
    console.log(c);
}

test_eval();

/**
 *   finite 有限的
 * infinite 无限的
 *
 *   defined 定义
 * undefined 未定义
 *
 * isFinite() // 是否是有限的
 */
const a = 1000 / 0; // Infinity
isFinite(a) // false
const b = 1000
isFinite(b) // true

/**
 * NaN: Not a Number -> NaN
 */
isNaN(a) // false， 因为 Infinity 是一个特殊的数字
isNaN('zxczasdajslkkjqweljx'); // true
isNaN(false); // false 因为 false 等价于 0
isNaN({name: 'bob'}); // true
/**
 * typeof [1, 2, 3]
 * 'object' 数组是个对象
 */
isNaN([1, 2, 3]); // true

/**
 * 把（只包含数字的）字符串转为小数
 */
const num_str = '3.1415926535';
parseFloat(num_str);
const num_str2 = '3';
parseFloat(num_str2);

/**
 * 把（只包含数字的）字符串转为整数，会忽略小数部分
 */
parseInt(num_str); // 3































